package 其他.斗地主之顺子;


import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String s = scanner.nextLine();
        String[] strings = s.split(" ");
        int[] ints = new int[strings.length];
        ArrayList<Integer> list = new ArrayList<>();
        HashMap<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < strings.length; i++) {
            ints[i]=Integer.valueOf(mapping(strings[i]));
            if (!list.contains(ints[i])){
                list.add(ints[i]);
            }
            map.put(ints[i],map.getOrDefault(ints[i],0)+1);
        }

        // 对集合进行一个排序
        Collections.sort(list);
        ArrayList<Integer> path = new ArrayList<>();
        ArrayList<ArrayList<Integer>> arrayLists = new ArrayList<>();

        for (int i = 0; i < list.size(); i++) {
            // 可以到最后一个元素, 说明当前元素和上一个元素是相等的, 可以直接放进那个集合中
            if (i==list.size()-1){
                path.add(list.get(i));
                // 如果此时这个集合中的数量依然是<5的那么不足以成为一个连子 , 直接跳出,  也不用把它加入到结果集中
                if (path.size()<5){
                    break;
                }
                ArrayList<Integer> temp = new ArrayList<>();
                for (Integer item : path) {
                    temp.add(item);
                }
                arrayLists.add(temp);
                break; // 最后一次循环结束 , 跳出循环
            }
            // 当前元素
            int currentValue = list.get(i);
            // 把当前元素装进集合中
            path.add(list.get(i));

            Integer integer = map.get(list.get(i));
            int result = integer-1;
            // 如果数量为0 , 则删除list 中的该元素, 并且删除map中元素
            if (result==0){
                map.remove(list.get(i));
                // 如果出现这个集合的删减元素, 需要 进行一个下标的回退~
                list.remove(list.get(i));
                i--;

            }else {
                // 更新map , 该元素数量 减 1
                map.put(list.get(i),result);
            }

            // 收集结果
            if (list.get(i+1)-currentValue != 1  && path.size()>=5){
                ArrayList<Integer> temp = new ArrayList<>();
                for (Integer item : path) {
                    temp.add(item);
                }
                arrayLists.add(temp);

                //记录上次收集的结果的第一个数字: 并且是在map中还存在的, 从集合中从前向后遍历~
                //每次开始都是从集合的第1个元素开始的,  也就是下标为0
                // 清空这个path 集合
                path.clear();

            }
            // 出现不连续的情况,但是这个数量<= 5 张牌
            if (list.get(i+1)-currentValue!=1&&path.size()<5){
                // 直接清空集合
                path.clear();
            }

        }

        if (arrayLists.size()==0){
            System.out.println("NO");
        }else {
            for (int i = 0; i < arrayLists.size(); i++) {
                for (Integer item : arrayLists.get(i)) {
                    System.out.print(reversMapping(item)+" ");
                }
                System.out.println();
            }
        }


    }

    public static int mapping(String a){
        switch (a){
            case "J":
                return 11;
            case "Q":
                return 12;
            case "K":
                return 13;
            case "A":
                return 14;
            case "2":
                return -1;
            default:
                return Integer.valueOf(a);
        }
    }

    public static String reversMapping(int a){
        switch (a){
            case 11:
                return "J";
            case 12:
                return "Q";
            case 13:
                return "K";
            case 14:
                return "A";
            default:
                return String.valueOf(a);
        }
    }
}
